/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package controladoresJPA;

import controladoresJPA.exceptions.IllegalOrphanException;
import controladoresJPA.exceptions.NonexistentEntityException;
import controladoresJPA.exceptions.RollbackFailureException;
import java.io.Serializable;
import javax.persistence.Query;
import javax.persistence.EntityNotFoundException;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import modelo.Consumidor;
import java.util.ArrayList;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.TypedQuery;
import javax.transaction.UserTransaction;
import modelo.OperarConsumo;
import modelo.LigaUsuarioConsumidor;
import modelo.TransferenciaIngreso;
import modelo.Consumible;
import modelo.OperarIngreso;
import modelo.Categoria;
import modelo.ConsumidorPersona;
import modelo.Direccion;
import modelo.Persona;
import modelo.PersonaContacto;
import modelo.Usuario;

/**
 *
 * @author Francisco
 */
public class UsuarioJpaController implements Serializable {

    public UsuarioJpaController(UserTransaction utx, EntityManagerFactory emf) {
        this.utx = utx;
        this.emf = emf;
    }
    private UserTransaction utx = null;
    private EntityManagerFactory emf = null;

    public EntityManager getEntityManager() {
        return emf.createEntityManager();
    }
    
    public void alta(Usuario usuario, Persona persona, ConsumidorPersona consumidorPersona, Direccion direccion,
            List<PersonaContacto> personaContactos) 
            throws RollbackFailureException, Exception{
        EntityManager em = null;
        try{
            utx.begin();
            em = getEntityManager();
            em.persist(usuario);
            em.persist(direccion);
            persona.setIdDireccion(direccion);
            persona.setIdUsuario(usuario);
            em.persist(persona);
            for(PersonaContacto p : personaContactos){
                   p.setIdPersona(persona);
                   em.persist(p);
                }
            consumidorPersona.setIdPersona(persona);
            consumidorPersona.setIdUsuario(usuario);
            em.persist(consumidorPersona);
            utx.commit();
            utx.begin();
                Query strQuery = em.createNativeQuery("UPDATE prp.usuario SET id_consumidor = " + 
                    consumidorPersona.getIdConsumidor() + " WHERE id_usuario = " + usuario.getIdUsuario());
                strQuery.executeUpdate();
            utx.commit();
        }catch (Exception ex) {
            try {
                utx.rollback();
            } catch (Exception re) {
                throw new RollbackFailureException("Ocurrio un error al dar de alta el usuario.", re);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void create(Usuario usuario) throws RollbackFailureException, Exception {
        if (usuario.getConsumidorList() == null) {
            usuario.setConsumidorList(new ArrayList<Consumidor>());
        }
        if (usuario.getOperarConsumoList() == null) {
            usuario.setOperarConsumoList(new ArrayList<OperarConsumo>());
        }
        if (usuario.getLigaUsuarioConsumidorList() == null) {
            usuario.setLigaUsuarioConsumidorList(new ArrayList<LigaUsuarioConsumidor>());
        }
        if (usuario.getTransferenciaIngresoList() == null) {
            usuario.setTransferenciaIngresoList(new ArrayList<TransferenciaIngreso>());
        }
        if (usuario.getConsumibleList() == null) {
            usuario.setConsumibleList(new ArrayList<Consumible>());
        }
        if (usuario.getOperarIngresoList() == null) {
            usuario.setOperarIngresoList(new ArrayList<OperarIngreso>());
        }
        if (usuario.getCategoriaList() == null) {
            usuario.setCategoriaList(new ArrayList<Categoria>());
        }
        if (usuario.getPersonaList() == null) {
            usuario.setPersonaList(new ArrayList<Persona>());
        }
        EntityManager em = null;
        try {
            utx.begin();
            em = getEntityManager();
            Consumidor idConsumidor = usuario.getIdConsumidor();
            if (idConsumidor != null) {
                idConsumidor = em.getReference(idConsumidor.getClass(), idConsumidor.getIdConsumidor());
                usuario.setIdConsumidor(idConsumidor);
            }
            List<Consumidor> attachedConsumidorList = new ArrayList<Consumidor>();
            for (Consumidor consumidorListConsumidorToAttach : usuario.getConsumidorList()) {
                consumidorListConsumidorToAttach = em.getReference(consumidorListConsumidorToAttach.getClass(), consumidorListConsumidorToAttach.getIdConsumidor());
                attachedConsumidorList.add(consumidorListConsumidorToAttach);
            }
            usuario.setConsumidorList(attachedConsumidorList);
            List<OperarConsumo> attachedOperarConsumoList = new ArrayList<OperarConsumo>();
            for (OperarConsumo operarConsumoListOperarConsumoToAttach : usuario.getOperarConsumoList()) {
                operarConsumoListOperarConsumoToAttach = em.getReference(operarConsumoListOperarConsumoToAttach.getClass(), operarConsumoListOperarConsumoToAttach.getIdOperarConsumo());
                attachedOperarConsumoList.add(operarConsumoListOperarConsumoToAttach);
            }
            usuario.setOperarConsumoList(attachedOperarConsumoList);
            List<LigaUsuarioConsumidor> attachedLigaUsuarioConsumidorList = new ArrayList<LigaUsuarioConsumidor>();
            for (LigaUsuarioConsumidor ligaUsuarioConsumidorListLigaUsuarioConsumidorToAttach : usuario.getLigaUsuarioConsumidorList()) {
                ligaUsuarioConsumidorListLigaUsuarioConsumidorToAttach = em.getReference(ligaUsuarioConsumidorListLigaUsuarioConsumidorToAttach.getClass(), ligaUsuarioConsumidorListLigaUsuarioConsumidorToAttach.getIdLigaUsuarioConsumidor());
                attachedLigaUsuarioConsumidorList.add(ligaUsuarioConsumidorListLigaUsuarioConsumidorToAttach);
            }
            usuario.setLigaUsuarioConsumidorList(attachedLigaUsuarioConsumidorList);
            List<TransferenciaIngreso> attachedTransferenciaIngresoList = new ArrayList<TransferenciaIngreso>();
            for (TransferenciaIngreso transferenciaIngresoListTransferenciaIngresoToAttach : usuario.getTransferenciaIngresoList()) {
                transferenciaIngresoListTransferenciaIngresoToAttach = em.getReference(transferenciaIngresoListTransferenciaIngresoToAttach.getClass(), transferenciaIngresoListTransferenciaIngresoToAttach.getIdTransferenciaIngreso());
                attachedTransferenciaIngresoList.add(transferenciaIngresoListTransferenciaIngresoToAttach);
            }
            usuario.setTransferenciaIngresoList(attachedTransferenciaIngresoList);
            List<Consumible> attachedConsumibleList = new ArrayList<Consumible>();
            for (Consumible consumibleListConsumibleToAttach : usuario.getConsumibleList()) {
                consumibleListConsumibleToAttach = em.getReference(consumibleListConsumibleToAttach.getClass(), consumibleListConsumibleToAttach.getIdConsumible());
                attachedConsumibleList.add(consumibleListConsumibleToAttach);
            }
            usuario.setConsumibleList(attachedConsumibleList);
            List<OperarIngreso> attachedOperarIngresoList = new ArrayList<OperarIngreso>();
            for (OperarIngreso operarIngresoListOperarIngresoToAttach : usuario.getOperarIngresoList()) {
                operarIngresoListOperarIngresoToAttach = em.getReference(operarIngresoListOperarIngresoToAttach.getClass(), operarIngresoListOperarIngresoToAttach.getIdOperarIngreso());
                attachedOperarIngresoList.add(operarIngresoListOperarIngresoToAttach);
            }
            usuario.setOperarIngresoList(attachedOperarIngresoList);
            List<Categoria> attachedCategoriaList = new ArrayList<Categoria>();
            for (Categoria categoriaListCategoriaToAttach : usuario.getCategoriaList()) {
                categoriaListCategoriaToAttach = em.getReference(categoriaListCategoriaToAttach.getClass(), categoriaListCategoriaToAttach.getIdCategoria());
                attachedCategoriaList.add(categoriaListCategoriaToAttach);
            }
            usuario.setCategoriaList(attachedCategoriaList);
            List<Persona> attachedPersonaList = new ArrayList<Persona>();
            for (Persona personaListPersonaToAttach : usuario.getPersonaList()) {
                personaListPersonaToAttach = em.getReference(personaListPersonaToAttach.getClass(), personaListPersonaToAttach.getIdPersona());
                attachedPersonaList.add(personaListPersonaToAttach);
            }
            usuario.setPersonaList(attachedPersonaList);
            em.persist(usuario);
            if (idConsumidor != null) {
                Usuario oldIdUsuarioOfIdConsumidor = idConsumidor.getIdUsuario();
                if (oldIdUsuarioOfIdConsumidor != null) {
                    oldIdUsuarioOfIdConsumidor.setIdConsumidor(null);
                    oldIdUsuarioOfIdConsumidor = em.merge(oldIdUsuarioOfIdConsumidor);
                }
                idConsumidor.setIdUsuario(usuario);
                idConsumidor = em.merge(idConsumidor);
            }
            for (Consumidor consumidorListConsumidor : usuario.getConsumidorList()) {
                Usuario oldIdUsuarioOfConsumidorListConsumidor = consumidorListConsumidor.getIdUsuario();
                consumidorListConsumidor.setIdUsuario(usuario);
                consumidorListConsumidor = em.merge(consumidorListConsumidor);
                if (oldIdUsuarioOfConsumidorListConsumidor != null) {
                    oldIdUsuarioOfConsumidorListConsumidor.getConsumidorList().remove(consumidorListConsumidor);
                    oldIdUsuarioOfConsumidorListConsumidor = em.merge(oldIdUsuarioOfConsumidorListConsumidor);
                }
            }
            for (OperarConsumo operarConsumoListOperarConsumo : usuario.getOperarConsumoList()) {
                Usuario oldIdUsuarioOfOperarConsumoListOperarConsumo = operarConsumoListOperarConsumo.getIdUsuario();
                operarConsumoListOperarConsumo.setIdUsuario(usuario);
                operarConsumoListOperarConsumo = em.merge(operarConsumoListOperarConsumo);
                if (oldIdUsuarioOfOperarConsumoListOperarConsumo != null) {
                    oldIdUsuarioOfOperarConsumoListOperarConsumo.getOperarConsumoList().remove(operarConsumoListOperarConsumo);
                    oldIdUsuarioOfOperarConsumoListOperarConsumo = em.merge(oldIdUsuarioOfOperarConsumoListOperarConsumo);
                }
            }
            for (LigaUsuarioConsumidor ligaUsuarioConsumidorListLigaUsuarioConsumidor : usuario.getLigaUsuarioConsumidorList()) {
                Usuario oldIdUsuarioOfLigaUsuarioConsumidorListLigaUsuarioConsumidor = ligaUsuarioConsumidorListLigaUsuarioConsumidor.getIdUsuario();
                ligaUsuarioConsumidorListLigaUsuarioConsumidor.setIdUsuario(usuario);
                ligaUsuarioConsumidorListLigaUsuarioConsumidor = em.merge(ligaUsuarioConsumidorListLigaUsuarioConsumidor);
                if (oldIdUsuarioOfLigaUsuarioConsumidorListLigaUsuarioConsumidor != null) {
                    oldIdUsuarioOfLigaUsuarioConsumidorListLigaUsuarioConsumidor.getLigaUsuarioConsumidorList().remove(ligaUsuarioConsumidorListLigaUsuarioConsumidor);
                    oldIdUsuarioOfLigaUsuarioConsumidorListLigaUsuarioConsumidor = em.merge(oldIdUsuarioOfLigaUsuarioConsumidorListLigaUsuarioConsumidor);
                }
            }
            for (TransferenciaIngreso transferenciaIngresoListTransferenciaIngreso : usuario.getTransferenciaIngresoList()) {
                Usuario oldIdUsuarioDestinoOfTransferenciaIngresoListTransferenciaIngreso = transferenciaIngresoListTransferenciaIngreso.getIdUsuarioDestino();
                transferenciaIngresoListTransferenciaIngreso.setIdUsuarioDestino(usuario);
                transferenciaIngresoListTransferenciaIngreso = em.merge(transferenciaIngresoListTransferenciaIngreso);
                if (oldIdUsuarioDestinoOfTransferenciaIngresoListTransferenciaIngreso != null) {
                    oldIdUsuarioDestinoOfTransferenciaIngresoListTransferenciaIngreso.getTransferenciaIngresoList().remove(transferenciaIngresoListTransferenciaIngreso);
                    oldIdUsuarioDestinoOfTransferenciaIngresoListTransferenciaIngreso = em.merge(oldIdUsuarioDestinoOfTransferenciaIngresoListTransferenciaIngreso);
                }
            }
            for (Consumible consumibleListConsumible : usuario.getConsumibleList()) {
                Usuario oldIdUsuarioOfConsumibleListConsumible = consumibleListConsumible.getIdUsuario();
                consumibleListConsumible.setIdUsuario(usuario);
                consumibleListConsumible = em.merge(consumibleListConsumible);
                if (oldIdUsuarioOfConsumibleListConsumible != null) {
                    oldIdUsuarioOfConsumibleListConsumible.getConsumibleList().remove(consumibleListConsumible);
                    oldIdUsuarioOfConsumibleListConsumible = em.merge(oldIdUsuarioOfConsumibleListConsumible);
                }
            }
            for (OperarIngreso operarIngresoListOperarIngreso : usuario.getOperarIngresoList()) {
                Usuario oldIdUsuarioOfOperarIngresoListOperarIngreso = operarIngresoListOperarIngreso.getIdUsuario();
                operarIngresoListOperarIngreso.setIdUsuario(usuario);
                operarIngresoListOperarIngreso = em.merge(operarIngresoListOperarIngreso);
                if (oldIdUsuarioOfOperarIngresoListOperarIngreso != null) {
                    oldIdUsuarioOfOperarIngresoListOperarIngreso.getOperarIngresoList().remove(operarIngresoListOperarIngreso);
                    oldIdUsuarioOfOperarIngresoListOperarIngreso = em.merge(oldIdUsuarioOfOperarIngresoListOperarIngreso);
                }
            }
            for (Categoria categoriaListCategoria : usuario.getCategoriaList()) {
                Usuario oldIdUsuarioOfCategoriaListCategoria = categoriaListCategoria.getIdUsuario();
                categoriaListCategoria.setIdUsuario(usuario);
                categoriaListCategoria = em.merge(categoriaListCategoria);
                if (oldIdUsuarioOfCategoriaListCategoria != null) {
                    oldIdUsuarioOfCategoriaListCategoria.getCategoriaList().remove(categoriaListCategoria);
                    oldIdUsuarioOfCategoriaListCategoria = em.merge(oldIdUsuarioOfCategoriaListCategoria);
                }
            }
            for (Persona personaListPersona : usuario.getPersonaList()) {
                Usuario oldIdUsuarioOfPersonaListPersona = personaListPersona.getIdUsuario();
                personaListPersona.setIdUsuario(usuario);
                personaListPersona = em.merge(personaListPersona);
                if (oldIdUsuarioOfPersonaListPersona != null) {
                    oldIdUsuarioOfPersonaListPersona.getPersonaList().remove(personaListPersona);
                    oldIdUsuarioOfPersonaListPersona = em.merge(oldIdUsuarioOfPersonaListPersona);
                }
            }
            utx.commit();
        } catch (Exception ex) {
            try {
                utx.rollback();
            } catch (Exception re) {
                throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void edit(Usuario usuario) throws IllegalOrphanException, NonexistentEntityException, RollbackFailureException, Exception {
        EntityManager em = null;
        try {
            utx.begin();
            em = getEntityManager();
            Usuario persistentUsuario = em.find(Usuario.class, usuario.getIdUsuario());
            Consumidor idConsumidorOld = persistentUsuario.getIdConsumidor();
            Consumidor idConsumidorNew = usuario.getIdConsumidor();
            List<Consumidor> consumidorListOld = persistentUsuario.getConsumidorList();
            List<Consumidor> consumidorListNew = usuario.getConsumidorList();
            List<OperarConsumo> operarConsumoListOld = persistentUsuario.getOperarConsumoList();
            List<OperarConsumo> operarConsumoListNew = usuario.getOperarConsumoList();
            List<LigaUsuarioConsumidor> ligaUsuarioConsumidorListOld = persistentUsuario.getLigaUsuarioConsumidorList();
            List<LigaUsuarioConsumidor> ligaUsuarioConsumidorListNew = usuario.getLigaUsuarioConsumidorList();
            List<TransferenciaIngreso> transferenciaIngresoListOld = persistentUsuario.getTransferenciaIngresoList();
            List<TransferenciaIngreso> transferenciaIngresoListNew = usuario.getTransferenciaIngresoList();
            List<Consumible> consumibleListOld = persistentUsuario.getConsumibleList();
            List<Consumible> consumibleListNew = usuario.getConsumibleList();
            List<OperarIngreso> operarIngresoListOld = persistentUsuario.getOperarIngresoList();
            List<OperarIngreso> operarIngresoListNew = usuario.getOperarIngresoList();
            List<Categoria> categoriaListOld = persistentUsuario.getCategoriaList();
            List<Categoria> categoriaListNew = usuario.getCategoriaList();
            List<Persona> personaListOld = persistentUsuario.getPersonaList();
            List<Persona> personaListNew = usuario.getPersonaList();
            List<String> illegalOrphanMessages = null;
            if (idConsumidorOld != null && !idConsumidorOld.equals(idConsumidorNew)) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("You must retain Consumidor " + idConsumidorOld + " since its idUsuario field is not nullable.");
            }
            for (Consumidor consumidorListOldConsumidor : consumidorListOld) {
                if (!consumidorListNew.contains(consumidorListOldConsumidor)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Consumidor " + consumidorListOldConsumidor + " since its idUsuario field is not nullable.");
                }
            }
            for (OperarConsumo operarConsumoListOldOperarConsumo : operarConsumoListOld) {
                if (!operarConsumoListNew.contains(operarConsumoListOldOperarConsumo)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain OperarConsumo " + operarConsumoListOldOperarConsumo + " since its idUsuario field is not nullable.");
                }
            }
            for (LigaUsuarioConsumidor ligaUsuarioConsumidorListOldLigaUsuarioConsumidor : ligaUsuarioConsumidorListOld) {
                if (!ligaUsuarioConsumidorListNew.contains(ligaUsuarioConsumidorListOldLigaUsuarioConsumidor)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain LigaUsuarioConsumidor " + ligaUsuarioConsumidorListOldLigaUsuarioConsumidor + " since its idUsuario field is not nullable.");
                }
            }
            for (TransferenciaIngreso transferenciaIngresoListOldTransferenciaIngreso : transferenciaIngresoListOld) {
                if (!transferenciaIngresoListNew.contains(transferenciaIngresoListOldTransferenciaIngreso)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain TransferenciaIngreso " + transferenciaIngresoListOldTransferenciaIngreso + " since its idUsuarioDestino field is not nullable.");
                }
            }
            for (Consumible consumibleListOldConsumible : consumibleListOld) {
                if (!consumibleListNew.contains(consumibleListOldConsumible)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Consumible " + consumibleListOldConsumible + " since its idUsuario field is not nullable.");
                }
            }
            for (OperarIngreso operarIngresoListOldOperarIngreso : operarIngresoListOld) {
                if (!operarIngresoListNew.contains(operarIngresoListOldOperarIngreso)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain OperarIngreso " + operarIngresoListOldOperarIngreso + " since its idUsuario field is not nullable.");
                }
            }
            for (Categoria categoriaListOldCategoria : categoriaListOld) {
                if (!categoriaListNew.contains(categoriaListOldCategoria)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Categoria " + categoriaListOldCategoria + " since its idUsuario field is not nullable.");
                }
            }
            for (Persona personaListOldPersona : personaListOld) {
                if (!personaListNew.contains(personaListOldPersona)) {
                    if (illegalOrphanMessages == null) {
                        illegalOrphanMessages = new ArrayList<String>();
                    }
                    illegalOrphanMessages.add("You must retain Persona " + personaListOldPersona + " since its idUsuario field is not nullable.");
                }
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            if (idConsumidorNew != null) {
                idConsumidorNew = em.getReference(idConsumidorNew.getClass(), idConsumidorNew.getIdConsumidor());
                usuario.setIdConsumidor(idConsumidorNew);
            }
            List<Consumidor> attachedConsumidorListNew = new ArrayList<Consumidor>();
            for (Consumidor consumidorListNewConsumidorToAttach : consumidorListNew) {
                consumidorListNewConsumidorToAttach = em.getReference(consumidorListNewConsumidorToAttach.getClass(), consumidorListNewConsumidorToAttach.getIdConsumidor());
                attachedConsumidorListNew.add(consumidorListNewConsumidorToAttach);
            }
            consumidorListNew = attachedConsumidorListNew;
            usuario.setConsumidorList(consumidorListNew);
            List<OperarConsumo> attachedOperarConsumoListNew = new ArrayList<OperarConsumo>();
            for (OperarConsumo operarConsumoListNewOperarConsumoToAttach : operarConsumoListNew) {
                operarConsumoListNewOperarConsumoToAttach = em.getReference(operarConsumoListNewOperarConsumoToAttach.getClass(), operarConsumoListNewOperarConsumoToAttach.getIdOperarConsumo());
                attachedOperarConsumoListNew.add(operarConsumoListNewOperarConsumoToAttach);
            }
            operarConsumoListNew = attachedOperarConsumoListNew;
            usuario.setOperarConsumoList(operarConsumoListNew);
            List<LigaUsuarioConsumidor> attachedLigaUsuarioConsumidorListNew = new ArrayList<LigaUsuarioConsumidor>();
            for (LigaUsuarioConsumidor ligaUsuarioConsumidorListNewLigaUsuarioConsumidorToAttach : ligaUsuarioConsumidorListNew) {
                ligaUsuarioConsumidorListNewLigaUsuarioConsumidorToAttach = em.getReference(ligaUsuarioConsumidorListNewLigaUsuarioConsumidorToAttach.getClass(), ligaUsuarioConsumidorListNewLigaUsuarioConsumidorToAttach.getIdLigaUsuarioConsumidor());
                attachedLigaUsuarioConsumidorListNew.add(ligaUsuarioConsumidorListNewLigaUsuarioConsumidorToAttach);
            }
            ligaUsuarioConsumidorListNew = attachedLigaUsuarioConsumidorListNew;
            usuario.setLigaUsuarioConsumidorList(ligaUsuarioConsumidorListNew);
            List<TransferenciaIngreso> attachedTransferenciaIngresoListNew = new ArrayList<TransferenciaIngreso>();
            for (TransferenciaIngreso transferenciaIngresoListNewTransferenciaIngresoToAttach : transferenciaIngresoListNew) {
                transferenciaIngresoListNewTransferenciaIngresoToAttach = em.getReference(transferenciaIngresoListNewTransferenciaIngresoToAttach.getClass(), transferenciaIngresoListNewTransferenciaIngresoToAttach.getIdTransferenciaIngreso());
                attachedTransferenciaIngresoListNew.add(transferenciaIngresoListNewTransferenciaIngresoToAttach);
            }
            transferenciaIngresoListNew = attachedTransferenciaIngresoListNew;
            usuario.setTransferenciaIngresoList(transferenciaIngresoListNew);
            List<Consumible> attachedConsumibleListNew = new ArrayList<Consumible>();
            for (Consumible consumibleListNewConsumibleToAttach : consumibleListNew) {
                consumibleListNewConsumibleToAttach = em.getReference(consumibleListNewConsumibleToAttach.getClass(), consumibleListNewConsumibleToAttach.getIdConsumible());
                attachedConsumibleListNew.add(consumibleListNewConsumibleToAttach);
            }
            consumibleListNew = attachedConsumibleListNew;
            usuario.setConsumibleList(consumibleListNew);
            List<OperarIngreso> attachedOperarIngresoListNew = new ArrayList<OperarIngreso>();
            for (OperarIngreso operarIngresoListNewOperarIngresoToAttach : operarIngresoListNew) {
                operarIngresoListNewOperarIngresoToAttach = em.getReference(operarIngresoListNewOperarIngresoToAttach.getClass(), operarIngresoListNewOperarIngresoToAttach.getIdOperarIngreso());
                attachedOperarIngresoListNew.add(operarIngresoListNewOperarIngresoToAttach);
            }
            operarIngresoListNew = attachedOperarIngresoListNew;
            usuario.setOperarIngresoList(operarIngresoListNew);
            List<Categoria> attachedCategoriaListNew = new ArrayList<Categoria>();
            for (Categoria categoriaListNewCategoriaToAttach : categoriaListNew) {
                categoriaListNewCategoriaToAttach = em.getReference(categoriaListNewCategoriaToAttach.getClass(), categoriaListNewCategoriaToAttach.getIdCategoria());
                attachedCategoriaListNew.add(categoriaListNewCategoriaToAttach);
            }
            categoriaListNew = attachedCategoriaListNew;
            usuario.setCategoriaList(categoriaListNew);
            List<Persona> attachedPersonaListNew = new ArrayList<Persona>();
            for (Persona personaListNewPersonaToAttach : personaListNew) {
                personaListNewPersonaToAttach = em.getReference(personaListNewPersonaToAttach.getClass(), personaListNewPersonaToAttach.getIdPersona());
                attachedPersonaListNew.add(personaListNewPersonaToAttach);
            }
            personaListNew = attachedPersonaListNew;
            usuario.setPersonaList(personaListNew);
            usuario = em.merge(usuario);
            if (idConsumidorNew != null && !idConsumidorNew.equals(idConsumidorOld)) {
                Usuario oldIdUsuarioOfIdConsumidor = idConsumidorNew.getIdUsuario();
                if (oldIdUsuarioOfIdConsumidor != null) {
                    oldIdUsuarioOfIdConsumidor.setIdConsumidor(null);
                    oldIdUsuarioOfIdConsumidor = em.merge(oldIdUsuarioOfIdConsumidor);
                }
                idConsumidorNew.setIdUsuario(usuario);
                idConsumidorNew = em.merge(idConsumidorNew);
            }
            for (Consumidor consumidorListNewConsumidor : consumidorListNew) {
                if (!consumidorListOld.contains(consumidorListNewConsumidor)) {
                    Usuario oldIdUsuarioOfConsumidorListNewConsumidor = consumidorListNewConsumidor.getIdUsuario();
                    consumidorListNewConsumidor.setIdUsuario(usuario);
                    consumidorListNewConsumidor = em.merge(consumidorListNewConsumidor);
                    if (oldIdUsuarioOfConsumidorListNewConsumidor != null && !oldIdUsuarioOfConsumidorListNewConsumidor.equals(usuario)) {
                        oldIdUsuarioOfConsumidorListNewConsumidor.getConsumidorList().remove(consumidorListNewConsumidor);
                        oldIdUsuarioOfConsumidorListNewConsumidor = em.merge(oldIdUsuarioOfConsumidorListNewConsumidor);
                    }
                }
            }
            for (OperarConsumo operarConsumoListNewOperarConsumo : operarConsumoListNew) {
                if (!operarConsumoListOld.contains(operarConsumoListNewOperarConsumo)) {
                    Usuario oldIdUsuarioOfOperarConsumoListNewOperarConsumo = operarConsumoListNewOperarConsumo.getIdUsuario();
                    operarConsumoListNewOperarConsumo.setIdUsuario(usuario);
                    operarConsumoListNewOperarConsumo = em.merge(operarConsumoListNewOperarConsumo);
                    if (oldIdUsuarioOfOperarConsumoListNewOperarConsumo != null && !oldIdUsuarioOfOperarConsumoListNewOperarConsumo.equals(usuario)) {
                        oldIdUsuarioOfOperarConsumoListNewOperarConsumo.getOperarConsumoList().remove(operarConsumoListNewOperarConsumo);
                        oldIdUsuarioOfOperarConsumoListNewOperarConsumo = em.merge(oldIdUsuarioOfOperarConsumoListNewOperarConsumo);
                    }
                }
            }
            for (LigaUsuarioConsumidor ligaUsuarioConsumidorListNewLigaUsuarioConsumidor : ligaUsuarioConsumidorListNew) {
                if (!ligaUsuarioConsumidorListOld.contains(ligaUsuarioConsumidorListNewLigaUsuarioConsumidor)) {
                    Usuario oldIdUsuarioOfLigaUsuarioConsumidorListNewLigaUsuarioConsumidor = ligaUsuarioConsumidorListNewLigaUsuarioConsumidor.getIdUsuario();
                    ligaUsuarioConsumidorListNewLigaUsuarioConsumidor.setIdUsuario(usuario);
                    ligaUsuarioConsumidorListNewLigaUsuarioConsumidor = em.merge(ligaUsuarioConsumidorListNewLigaUsuarioConsumidor);
                    if (oldIdUsuarioOfLigaUsuarioConsumidorListNewLigaUsuarioConsumidor != null && !oldIdUsuarioOfLigaUsuarioConsumidorListNewLigaUsuarioConsumidor.equals(usuario)) {
                        oldIdUsuarioOfLigaUsuarioConsumidorListNewLigaUsuarioConsumidor.getLigaUsuarioConsumidorList().remove(ligaUsuarioConsumidorListNewLigaUsuarioConsumidor);
                        oldIdUsuarioOfLigaUsuarioConsumidorListNewLigaUsuarioConsumidor = em.merge(oldIdUsuarioOfLigaUsuarioConsumidorListNewLigaUsuarioConsumidor);
                    }
                }
            }
            for (TransferenciaIngreso transferenciaIngresoListNewTransferenciaIngreso : transferenciaIngresoListNew) {
                if (!transferenciaIngresoListOld.contains(transferenciaIngresoListNewTransferenciaIngreso)) {
                    Usuario oldIdUsuarioDestinoOfTransferenciaIngresoListNewTransferenciaIngreso = transferenciaIngresoListNewTransferenciaIngreso.getIdUsuarioDestino();
                    transferenciaIngresoListNewTransferenciaIngreso.setIdUsuarioDestino(usuario);
                    transferenciaIngresoListNewTransferenciaIngreso = em.merge(transferenciaIngresoListNewTransferenciaIngreso);
                    if (oldIdUsuarioDestinoOfTransferenciaIngresoListNewTransferenciaIngreso != null && !oldIdUsuarioDestinoOfTransferenciaIngresoListNewTransferenciaIngreso.equals(usuario)) {
                        oldIdUsuarioDestinoOfTransferenciaIngresoListNewTransferenciaIngreso.getTransferenciaIngresoList().remove(transferenciaIngresoListNewTransferenciaIngreso);
                        oldIdUsuarioDestinoOfTransferenciaIngresoListNewTransferenciaIngreso = em.merge(oldIdUsuarioDestinoOfTransferenciaIngresoListNewTransferenciaIngreso);
                    }
                }
            }
            for (Consumible consumibleListNewConsumible : consumibleListNew) {
                if (!consumibleListOld.contains(consumibleListNewConsumible)) {
                    Usuario oldIdUsuarioOfConsumibleListNewConsumible = consumibleListNewConsumible.getIdUsuario();
                    consumibleListNewConsumible.setIdUsuario(usuario);
                    consumibleListNewConsumible = em.merge(consumibleListNewConsumible);
                    if (oldIdUsuarioOfConsumibleListNewConsumible != null && !oldIdUsuarioOfConsumibleListNewConsumible.equals(usuario)) {
                        oldIdUsuarioOfConsumibleListNewConsumible.getConsumibleList().remove(consumibleListNewConsumible);
                        oldIdUsuarioOfConsumibleListNewConsumible = em.merge(oldIdUsuarioOfConsumibleListNewConsumible);
                    }
                }
            }
            for (OperarIngreso operarIngresoListNewOperarIngreso : operarIngresoListNew) {
                if (!operarIngresoListOld.contains(operarIngresoListNewOperarIngreso)) {
                    Usuario oldIdUsuarioOfOperarIngresoListNewOperarIngreso = operarIngresoListNewOperarIngreso.getIdUsuario();
                    operarIngresoListNewOperarIngreso.setIdUsuario(usuario);
                    operarIngresoListNewOperarIngreso = em.merge(operarIngresoListNewOperarIngreso);
                    if (oldIdUsuarioOfOperarIngresoListNewOperarIngreso != null && !oldIdUsuarioOfOperarIngresoListNewOperarIngreso.equals(usuario)) {
                        oldIdUsuarioOfOperarIngresoListNewOperarIngreso.getOperarIngresoList().remove(operarIngresoListNewOperarIngreso);
                        oldIdUsuarioOfOperarIngresoListNewOperarIngreso = em.merge(oldIdUsuarioOfOperarIngresoListNewOperarIngreso);
                    }
                }
            }
            for (Categoria categoriaListNewCategoria : categoriaListNew) {
                if (!categoriaListOld.contains(categoriaListNewCategoria)) {
                    Usuario oldIdUsuarioOfCategoriaListNewCategoria = categoriaListNewCategoria.getIdUsuario();
                    categoriaListNewCategoria.setIdUsuario(usuario);
                    categoriaListNewCategoria = em.merge(categoriaListNewCategoria);
                    if (oldIdUsuarioOfCategoriaListNewCategoria != null && !oldIdUsuarioOfCategoriaListNewCategoria.equals(usuario)) {
                        oldIdUsuarioOfCategoriaListNewCategoria.getCategoriaList().remove(categoriaListNewCategoria);
                        oldIdUsuarioOfCategoriaListNewCategoria = em.merge(oldIdUsuarioOfCategoriaListNewCategoria);
                    }
                }
            }
            for (Persona personaListNewPersona : personaListNew) {
                if (!personaListOld.contains(personaListNewPersona)) {
                    Usuario oldIdUsuarioOfPersonaListNewPersona = personaListNewPersona.getIdUsuario();
                    personaListNewPersona.setIdUsuario(usuario);
                    personaListNewPersona = em.merge(personaListNewPersona);
                    if (oldIdUsuarioOfPersonaListNewPersona != null && !oldIdUsuarioOfPersonaListNewPersona.equals(usuario)) {
                        oldIdUsuarioOfPersonaListNewPersona.getPersonaList().remove(personaListNewPersona);
                        oldIdUsuarioOfPersonaListNewPersona = em.merge(oldIdUsuarioOfPersonaListNewPersona);
                    }
                }
            }
            utx.commit();
        } catch (Exception ex) {
            try {
                utx.rollback();
            } catch (Exception re) {
                throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
            }
            String msg = ex.getLocalizedMessage();
            if (msg == null || msg.length() == 0) {
                Integer id = usuario.getIdUsuario();
                if (findUsuario(id) == null) {
                    throw new NonexistentEntityException("The usuario with id " + id + " no longer exists.");
                }
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public void destroy(Integer id) throws IllegalOrphanException, NonexistentEntityException, RollbackFailureException, Exception {
        EntityManager em = null;
        try {
            utx.begin();
            em = getEntityManager();
            Usuario usuario;
            try {
                usuario = em.getReference(Usuario.class, id);
                usuario.getIdUsuario();
            } catch (EntityNotFoundException enfe) {
                throw new NonexistentEntityException("The usuario with id " + id + " no longer exists.", enfe);
            }
            List<String> illegalOrphanMessages = null;
            Consumidor idConsumidorOrphanCheck = usuario.getIdConsumidor();
            if (idConsumidorOrphanCheck != null) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the Consumidor " + idConsumidorOrphanCheck + " in its idConsumidor field has a non-nullable idUsuario field.");
            }
            List<Consumidor> consumidorListOrphanCheck = usuario.getConsumidorList();
            for (Consumidor consumidorListOrphanCheckConsumidor : consumidorListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the Consumidor " + consumidorListOrphanCheckConsumidor + " in its consumidorList field has a non-nullable idUsuario field.");
            }
            List<OperarConsumo> operarConsumoListOrphanCheck = usuario.getOperarConsumoList();
            for (OperarConsumo operarConsumoListOrphanCheckOperarConsumo : operarConsumoListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the OperarConsumo " + operarConsumoListOrphanCheckOperarConsumo + " in its operarConsumoList field has a non-nullable idUsuario field.");
            }
            List<LigaUsuarioConsumidor> ligaUsuarioConsumidorListOrphanCheck = usuario.getLigaUsuarioConsumidorList();
            for (LigaUsuarioConsumidor ligaUsuarioConsumidorListOrphanCheckLigaUsuarioConsumidor : ligaUsuarioConsumidorListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the LigaUsuarioConsumidor " + ligaUsuarioConsumidorListOrphanCheckLigaUsuarioConsumidor + " in its ligaUsuarioConsumidorList field has a non-nullable idUsuario field.");
            }
            List<TransferenciaIngreso> transferenciaIngresoListOrphanCheck = usuario.getTransferenciaIngresoList();
            for (TransferenciaIngreso transferenciaIngresoListOrphanCheckTransferenciaIngreso : transferenciaIngresoListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the TransferenciaIngreso " + transferenciaIngresoListOrphanCheckTransferenciaIngreso + " in its transferenciaIngresoList field has a non-nullable idUsuarioDestino field.");
            }
            List<Consumible> consumibleListOrphanCheck = usuario.getConsumibleList();
            for (Consumible consumibleListOrphanCheckConsumible : consumibleListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the Consumible " + consumibleListOrphanCheckConsumible + " in its consumibleList field has a non-nullable idUsuario field.");
            }
            List<OperarIngreso> operarIngresoListOrphanCheck = usuario.getOperarIngresoList();
            for (OperarIngreso operarIngresoListOrphanCheckOperarIngreso : operarIngresoListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the OperarIngreso " + operarIngresoListOrphanCheckOperarIngreso + " in its operarIngresoList field has a non-nullable idUsuario field.");
            }
            List<Categoria> categoriaListOrphanCheck = usuario.getCategoriaList();
            for (Categoria categoriaListOrphanCheckCategoria : categoriaListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the Categoria " + categoriaListOrphanCheckCategoria + " in its categoriaList field has a non-nullable idUsuario field.");
            }
            List<Persona> personaListOrphanCheck = usuario.getPersonaList();
            for (Persona personaListOrphanCheckPersona : personaListOrphanCheck) {
                if (illegalOrphanMessages == null) {
                    illegalOrphanMessages = new ArrayList<String>();
                }
                illegalOrphanMessages.add("This Usuario (" + usuario + ") cannot be destroyed since the Persona " + personaListOrphanCheckPersona + " in its personaList field has a non-nullable idUsuario field.");
            }
            if (illegalOrphanMessages != null) {
                throw new IllegalOrphanException(illegalOrphanMessages);
            }
            em.remove(usuario);
            utx.commit();
        } catch (Exception ex) {
            try {
                utx.rollback();
            } catch (Exception re) {
                throw new RollbackFailureException("An error occurred attempting to roll back the transaction.", re);
            }
            throw ex;
        } finally {
            if (em != null) {
                em.close();
            }
        }
    }

    public List<Usuario> findUsuarioEntities() {
        return findUsuarioEntities(true, -1, -1);
    }

    public List<Usuario> findUsuarioEntities(int maxResults, int firstResult) {
        return findUsuarioEntities(false, maxResults, firstResult);
    }

    private List<Usuario> findUsuarioEntities(boolean all, int maxResults, int firstResult) {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Usuario.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    public Usuario findUsuario(Integer id) {
        EntityManager em = getEntityManager();
        try {
            return em.find(Usuario.class, id);
        } finally {
            em.close();
        }
    }
    
    public Usuario findUsuario(String nombreUsuario) {
        EntityManager em = getEntityManager();
        try {
            TypedQuery<Usuario> tq = em.createQuery("Select u from Usuario u Where u.nombreUsuario = :nomUsu", 
                    Usuario.class);
            tq.setParameter("nomUsu", nombreUsuario);
            return tq.getSingleResult();
        } finally {
            em.close();
        }
    }
    
    public List<Usuario> findUsuarioLigado(Integer idUsuario){
        EntityManager em = getEntityManager();
        try {
            TypedQuery<Usuario> tq = em.createQuery("Select l.idUsuario from LigaUsuarioConsumidor l "
                    + " Where l.idConsumidor.idUsuario.idUsuario = :idUsu and l.estatus='A'", 
                    Usuario.class);
            tq.setParameter("idUsu", idUsuario);
            return tq.getResultList();
        } finally {
            em.close();
        }
    }

    public int getUsuarioCount() {
        EntityManager em = getEntityManager();
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Usuario> rt = cq.from(Usuario.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}
